/**
 * SSE 控制器
 * 处理服务器发送事件的相关请求
 */

const SSEManager = require('../utils/sseManager');
const { getLogger } = require('../logger');
const logger = getLogger('controllers.sseController');

// 获取 SSE 管理器单例实例
const sseManager = SSEManager.getInstance();

class SSEController {
  /**
   * 建立 SSE 连接（无需认证，可用于公开通知）
   */
  static connectPublic(req, res) {
    
    try {
      // 创建连接但不关联用户
      const connectionId = sseManager.createConnection(req, res);
    

      // 可以在连接成功后做一些额外处理
      logger.info(`公共 SSE 连接已建立: ${connectionId}`);
      
      // 注意：这里不能关闭响应，因为 SSE 需要保持连接打开
    } catch (error) {
      logger.error('建立公共 SSE 连接失败:', error);
      res.status(500).json({
        success: false,
        message: '建立连接失败',
        error: error
      });
    }
  }

  /**
   * 建立 SSE 连接（需要认证，关联到特定用户）
   */
  static connectAuthenticated(req, res) {
    try {
      // 从认证中间件获取用户信息
      // 假设 authenticateToken 中间件已经设置了 req.user
      const userId = req.user?.id || req.user?.user_id;
      
      if (!userId) {
        return res.status(401).json({
          success: false,
          message: '用户未认证'
        });
      }
      
      // 创建连接并关联用户
      const connectionId = sseManager.createConnection(req, res, userId);
      
      // 发送用户专属的欢迎消息
      const clientId = (req.query && req.query.clientId) || req.headers['x-client-id'] || null;
      sseManager.sendMessage(connectionId, {
        type: 'welcome',
        data: {
          message: `欢迎回来，用户 ${userId}！`,
          timestamp: new Date().toISOString(),
          connectionId,
          clientId
        }
      });
      
      logger.info(`用户 ${userId} 的 SSE 连接已建立: ${connectionId}`);
      
    } catch (error) {
      logger.error('建立认证 SSE 连接失败:', error);
      res.status(500).json({
        success: false,
        message: '建立连接失败',
        error: error
      });
    }
  }

  /**
   * 发送通知给特定用户
   * 这个接口通常由其他业务逻辑调用，用于主动推送消息给用户
   */
  static sendToUser(req, res) {
    try {
      const { userId, eventType, data } = req.body;
      
      if (!userId || !data) {
        return res.status(400).json({
          success: false,
          message: '缺少必要参数 userId 或 data'
        });
      }
      
      // 发送消息到指定用户
      const sentCount = sseManager.sendToUser(userId, {
        type: eventType || 'notification',
        data
      });
      
      if (sentCount > 0) {
        res.json({
          success: true,
          message: `成功发送消息到用户 ${userId} 的 ${sentCount} 个连接`
        });
      } else {
        res.json({
          success: false,
          message: `用户 ${userId} 当前没有活跃的连接`
        });
      }
    } catch (error) {
      logger.error('发送消息给用户失败:', error);
      res.status(500).json({
        success: false,
        message: '发送消息失败',
        error: error
      });
    }
  }

  /**
   * 广播消息给所有连接的客户端
   */
  static broadcast(req, res) {
    try {
      const { eventType, data, filter } = req.body;
      
      if (!data) {
        return res.status(400).json({
          success: false,
          message: '缺少必要参数 data'
        });
      }
      
      let filterFn = null;
      if (filter && filter.userIds && Array.isArray(filter.userIds) && filter.userIds.length > 0) {
        // 创建用户 ID 过滤器
        const targetUserIds = new Set(filter.userIds);
        filterFn = (connection) => {
          return connection.userId && targetUserIds.has(connection.userId);
        };
      }
      
      // 广播消息
      const sentCount = sseManager.broadcast({
        type: eventType || 'broadcast',
        data
      }, filterFn);
      
      res.json({
        success: true,
        message: `成功广播消息到 ${sentCount} 个连接`
      });
    } catch (error) {
      logger.error('广播消息失败:', error);
      res.status(500).json({
        success: false,
        message: '广播消息失败',
        error: error
      });
    }
  }

  /**
   * 获取 SSE 连接统计信息
   */
  static getStats(req, res) {
    try {
      const stats = sseManager.getStats();
      res.json({
        success: true,
        data: stats
      });
    } catch (error) {
      logger.error('获取 SSE 统计信息失败:', error);
      res.status(500).json({
        success: false,
        message: '获取统计信息失败',
        error: error
      });
    }
  }

  /**
   * 获取特定用户的连接信息
   */
  static getUserConnections(req, res) {
    try {
      const { userId } = req.params;
      const userConns = sseManager.userConnections.get(userId) || new Set();
      res.json({
        success: true,
        data: {
          userId,
          connectionCount: userConns.size,
          active: userConns.size > 0
        }
      });
    } catch (error) {
      logger.error('获取用户连接信息失败:', error);
      res.status(500).json({
        success: false,
        message: '获取用户连接信息失败',
        error: error
      });
    }
  }

  /**
   * 断开特定用户的所有连接
   */
  static disconnectUser(req, res) {
    try {
      const { userId } = req.params;
      const userConns = sseManager.userConnections.get(userId) || new Set();
      const connectionIds = Array.from(userConns);
      
      connectionIds.forEach(connectionId => {
        sseManager.closeConnection(connectionId);
      });
      
      res.json({
        success: true,
        message: `已断开用户 ${userId} 的 ${connectionIds.length} 个连接`
      });
    } catch (error) {
      logger.error('断开用户连接失败:', error);
      res.status(500).json({
        success: false,
        message: '断开用户连接失败',
        error: error
      });
    }
  }
}

module.exports = SSEController;